public class Base {
	int a;
	int b;
}
public class Derived extends Base {
	int c;
	public void method() {
		a = 10; // 访问从父类中继承下来的a
		b = 20; // 访问从父类中继承下来的b
		c = 30; // 访问子类自己的c
	}
}


public class Base {
	public void methodA() {
		System.out.println("Base中的methodA()");
	}
}
public class Derived extends Base {
	public void methodB() {
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC() {
		methodB(); // 访问子类自己的methodB()
		methodA(); // 访问父类继承的methodA()
// methodD(); // 编译失败，在整个继承体系中没有发现方法methodD()
	}
}

public class Base {
	int a;
	int b;
	public void methodA() {
		System.out.println("Base中的methodA()");
	}
	public void methodB() {
		System.out.println("Base中的methodB()");
	}
}

public class Derived extends Base {
	int a; // 与父类中成员变量同名且类型相同
	char b; // 与父类中成员变量同名但类型不同
// 与父类中methodA()构成重载
	public void methodA(int a) {
		System.out.println("Derived中的method()方法");
	}
// 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
	public void methodB() {
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC() {
// 对于同名的成员变量，直接访问时，访问的都是子类的
		a = 100; // 等价于： this.a = 100;
		b = 101; // 等价于： this.b = 101;
// 注意：this是当前对象的引用
// 访问父类的成员变量时，需要借助super关键字
// super是获取到子类对象中从基类继承下来的部分
		super.a = 200;
		super.b = 201;
// 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
		methodA(); // 没有传参，访问父类中的methodA()
		methodA(20); // 传递int参数，访问子类中的methodA(int)
// 如果在子类中要访问重写的基类方法，则需要借助super关键字
		methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
		super.methodB(); // 访问基类的methodB()
	}
}


public class Base {
	public Base() {
		System.out.println("Base()");
	}
}
public class Derived extends Base {
	public Derived() {
		// super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
		// 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
		// 并且只能出现一次
		System.out.println("Derived()");
	}
}
public class Test {
	public static void main(String[] args) {
		Derived d = new Derived();
	}
}
结果打印：
Base()
Derived()



// 为了掩饰基类中不同访问权限在子类中的可见性，为了简单类B中就不设置成员方法了
// extend01包中
public class B {
	private int a;
	protected int b;
	public int c;
	int d;
}
// extend01包中
// 同一个包中的子类
public class D extends B {
	public void method() {
		// super.a = 10; // 编译报错，父类private成员在相同包子类中不可见
		super.b = 20; // 父类中protected成员在相同包子类中可以直接访问
		super.c = 30; // 父类中public成员在相同包子类中可以直接访问
		super.d = 40; // 父类中默认访问权限修饰的成员在相同包子类中可以直接访问
	}
}
// extend02包中
// 不同包中的子类
public class C extends B {
	public void method() {
		// super.a = 10; // 编译报错，父类中private成员在不同包子类中不可见
		super.b = 20; // 父类中protected修饰的成员在不同包子类中可以直接访问
		super.c = 30; // 父类中public修饰的成员在不同包子类中可以直接访问
		//super.d = 40; // 父类中默认访问权限修饰的成员在不同包子类中不能直接访问
	}
}
// extend02包中
// 不同包中的类
public class TestC {
	public static void main(String[] args) {
		C c = new C();
		c.method();
		// System.out.println(c.a); // 编译报错，父类中private成员在不同包其他类中不可见
		// System.out.println(c.b); // 父类中protected成员在不同包其他类中不能直接访问
		System.out.println(c.c); // 父类中public成员在不同包其他类中可以直接访问
		// System.out.println(c.d); // 父类中默认访问权限修饰的成员在不同包其他类中不能直接访问
	}
}


public class A {

}
public class B extends A {

}
public class c extends A {

}


final int a = 10;
a = 20; // 编译出错

final public class Animal {
	...
}
public class Bird extends Animal {
	...
}
// 编译出错
Error: (3, 27) java: 无法从最终com.yzy.Animal进行继



// 轮胎类
class Tire {
// ...
}
// 发动机类
class Engine {
// ...
}
// 车载系统类
class VehicleSystem {
// ...
}
class Car {
	private Tire tire; // 可以复用轮胎中的属性和方法
	private Engine engine; // 可以复用发动机中的属性和方法
	private VehicleSystem vs; // 可以复用车载系统中的属性和方法
// ...
}
// 奔驰是汽车
class Benz extend Car {
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}




public class TestAnimal {
	// 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
	public static void eatFood(Animal a) {
		a.eat();
	}
	// 3. 作返回值：返回任意子类对象
	public static Animal buyAnimal(String var) {
		if ("狗".equals(var) ) {
			return new Dog("狗狗", 1);
		} else if ("猫" .equals(var)) {
			return new Cat("猫猫", 1);
		} else {
			return null;
		}
	}
	public static void main(String[] args) {
		Animal cat = new Cat("元宝", 2); // 1. 直接赋值：子类对象赋值给父类对象
		Dog dog = new Dog("小七", 1);
		eatFood(cat);
		eatFood(dog);
		Animal animal = buyAnimal("狗");
		animal.eat();
		animal = buyAnimal("猫");
		animal.eat();
	}
}


public class TestAnimal {
	public static void main(String[] args) {
		Cat cat = new Cat("元宝", 2);
		Dog dog = new Dog("小七", 1);
		// 向上转型
		Animal animal = cat;
		animal.eat();
		animal = dog;
		animal.eat();
		// 编译失败，编译时编译器将animal当成Animal对象处理
		// 而Animal类中没有bark方法，因此编译失败
		// animal.bark();
		// 向上转型
		// 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
		// 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
		cat = (Cat)animal;
		cat.mew();
		// animal本来指向的就是狗，因此将animal还原为狗也是安全的
		dog = (Dog)animal;
		dog.bark();
	}
}



// 抽象类：被abstract修饰的类
public abstract class Shape {
	// 抽象方法：被abstract修饰的方法，没有方法体
	abstract public void draw();
	abstract void calcArea();
	// 抽象类也是类，也可以增加普通方法和属性
	public double getArea() {
		return area;
	}
	protected double area; // 面积
}



public interface 接口名称 {
	// 抽象方法
	public abstract void method1(); // public abstract 是固定搭配，可以不写
	public void method2();
	abstract void method3();
	void method4();
	// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}


public class 类名称 implements 接口名称 {
// ...
}



public class TestUSB {
	public static void main(String[] args) {
		USB usb = new USB();
	}
}
// Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化



public interface USB {
	void openDevice(); // 默认是public的
	void closeDevice(); // 默认是public的
}
public class Mouse implements USB {
	@Override
	void openDevice() {
		System.out.println("打开鼠标");
	}

}
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public




class Animal {
	protected String name;
	public Animal(String name) {
		this.name = name;
	}
}

nterface IFlying {
	void fly();
}
interface IRunning {
	void run();
}
interface ISwimming {
	void swim();
}


class Frog extends Animal implements IRunning, ISwimming {
	public Frog(String name) {
		super(name);
	}
	@Override
	public void run() {
		System.out.println(this.name + "正在往前跳");
	}
	@Override
	public void swim() {
		System.out.println(this.name + "正在蹬腿游泳");
	}
}




interface IRunning {
	void run();
}
interface ISwimming {
	void swim();
}
	// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
	...
}

while(it.hasNext())
{
	//do something
	it.next()
}

while(it.next())
{
	//do something
}